package o;

import android.util.Pair;
import androidx.annotation.Nullable;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.ParserException;
import com.google.android.exoplayer2.extractor.ts.TsPayloadReader.a;
import com.tencent.mm.opensdk.modelmsg.WXMediaMessage;
import java.util.Collections;

public final class agk implements agc {
    private String ʻ;
    private boolean ʻॱ;
    private int ʼ;
    private int ʽ;
    private Format ˊ;
    private int ˊॱ;
    private aef ˋ;
    private long ˋॱ;
    private final anc ˎ = new anc((int) WXMediaMessage.DESCRIPTION_LENGTH_LIMIT);
    private final String ˏ;
    private boolean ˏॱ;
    private int ͺ;
    private final ane ॱ = new ane(this.ˎ.ˏ);
    private int ॱˊ;
    private long ॱˋ;
    private int ॱˎ;
    private int ॱॱ;
    private long ॱᐝ;
    private int ᐝ;
    private int ᐝॱ;

    public agk(@Nullable String str) {
        this.ˏ = str;
    }

    public void ˏ() {
        this.ʽ = 0;
        this.ˏॱ = false;
    }

    public void ˏ(ady o_ady, a aVar) {
        aVar.ˊ();
        this.ˋ = o_ady.ˊ(aVar.ˏ(), 1);
        this.ʻ = aVar.ˎ();
    }

    public void ˋ(long j, int i) {
        this.ˋॱ = j;
    }

    public void ˊ(anc o_anc) throws ParserException {
        while (o_anc.ˊ() > 0) {
            int ʽ;
            switch (this.ʽ) {
                case 0:
                    if (o_anc.ʽ() != 86) {
                        break;
                    }
                    this.ʽ = 1;
                    break;
                case 1:
                    ʽ = o_anc.ʽ();
                    if ((ʽ & 224) != 224) {
                        if (ʽ == 86) {
                            break;
                        }
                        this.ʽ = 0;
                        break;
                    }
                    this.ॱॱ = ʽ;
                    this.ʽ = 2;
                    break;
                case 2:
                    this.ᐝ = ((this.ॱॱ & -225) << 8) | o_anc.ʽ();
                    if (this.ᐝ > this.ˎ.ˏ.length) {
                        ॱ(this.ᐝ);
                    }
                    this.ʼ = 0;
                    this.ʽ = 3;
                    break;
                case 3:
                    ʽ = Math.min(o_anc.ˊ(), this.ᐝ - this.ʼ);
                    o_anc.ˎ(this.ॱ.ˎ, this.ʼ, ʽ);
                    this.ʼ = ʽ + this.ʼ;
                    if (this.ʼ != this.ᐝ) {
                        break;
                    }
                    this.ॱ.ˋ(0);
                    ॱ(this.ॱ);
                    this.ʽ = 0;
                    break;
                default:
                    throw new IllegalStateException();
            }
        }
    }

    public void ˋ() {
    }

    private void ॱ(ane o_ane) throws ParserException {
        if (!o_ane.ˊ()) {
            this.ˏॱ = true;
            ˏ(o_ane);
        } else if (!this.ˏॱ) {
            return;
        }
        if (this.ͺ != 0) {
            throw new ParserException();
        } else if (this.ॱˊ != 0) {
            throw new ParserException();
        } else {
            ॱ(o_ane, ˊ(o_ane));
            if (this.ʻॱ) {
                o_ane.ˎ((int) this.ॱᐝ);
            }
        }
    }

    private void ˏ(ane o_ane) throws ParserException {
        int ॱ = o_ane.ॱ(1);
        this.ͺ = ॱ == 1 ? o_ane.ॱ(1) : 0;
        if (this.ͺ == 0) {
            if (ॱ == 1) {
                ʼ(o_ane);
            }
            if (o_ane.ˊ()) {
                this.ॱˊ = o_ane.ॱ(6);
                int ॱ2 = o_ane.ॱ(4);
                int ॱ3 = o_ane.ॱ(3);
                if (ॱ2 == 0 && ॱ3 == 0) {
                    if (ॱ == 0) {
                        ॱ2 = o_ane.ॱ();
                        ॱ3 = ˋ(o_ane);
                        o_ane.ˋ(ॱ2);
                        Object obj = new byte[((ॱ3 + 7) / 8)];
                        o_ane.ˋ(obj, 0, ॱ3);
                        Format ˎ = Format.ˎ(this.ʻ, "audio/mp4a-latm", null, -1, -1, this.ᐝॱ, this.ॱˎ, Collections.singletonList(obj), null, 0, this.ˏ);
                        if (!ˎ.equals(this.ˊ)) {
                            this.ˊ = ˎ;
                            this.ॱˋ = 1024000000 / ((long) ˎ.ʼॱ);
                            this.ˋ.ˎ(ˎ);
                        }
                    } else {
                        o_ane.ˎ(((int) ʼ(o_ane)) - ˋ(o_ane));
                    }
                    ˎ(o_ane);
                    this.ʻॱ = o_ane.ˊ();
                    this.ॱᐝ = 0;
                    if (this.ʻॱ) {
                        if (ॱ == 1) {
                            this.ॱᐝ = ʼ(o_ane);
                        } else {
                            boolean ˊ;
                            do {
                                ˊ = o_ane.ˊ();
                                this.ॱᐝ = (this.ॱᐝ << 8) + ((long) o_ane.ॱ(8));
                            } while (ˊ);
                        }
                    }
                    if (o_ane.ˊ()) {
                        o_ane.ˎ(8);
                        return;
                    }
                    return;
                }
                throw new ParserException();
            }
            throw new ParserException();
        }
        throw new ParserException();
    }

    private void ˎ(ane o_ane) {
        this.ˊॱ = o_ane.ॱ(3);
        switch (this.ˊॱ) {
            case 0:
                o_ane.ˎ(8);
                return;
            case 1:
                o_ane.ˎ(9);
                return;
            case 3:
            case 4:
            case 5:
                o_ane.ˎ(6);
                return;
            case 6:
            case 7:
                o_ane.ˎ(1);
                return;
            default:
                throw new IllegalStateException();
        }
    }

    private int ˋ(ane o_ane) throws ParserException {
        int ˏ = o_ane.ˏ();
        Pair ˋ = amr.ˋ(o_ane, true);
        this.ॱˎ = ((Integer) ˋ.first).intValue();
        this.ᐝॱ = ((Integer) ˋ.second).intValue();
        return ˏ - o_ane.ˏ();
    }

    private int ˊ(ane o_ane) throws ParserException {
        int i = 0;
        if (this.ˊॱ == 0) {
            int ॱ;
            do {
                ॱ = o_ane.ॱ(8);
                i += ॱ;
            } while (ॱ == 255);
            return i;
        }
        throw new ParserException();
    }

    private void ॱ(ane o_ane, int i) {
        int ॱ = o_ane.ॱ();
        if ((ॱ & 7) == 0) {
            this.ˎ.ˋ(ॱ >> 3);
        } else {
            o_ane.ˋ(this.ˎ.ˏ, 0, i * 8);
            this.ˎ.ˋ(0);
        }
        this.ˋ.ˎ(this.ˎ, i);
        this.ˋ.ˋ(this.ˋॱ, 1, i, 0, null);
        this.ˋॱ += this.ॱˋ;
    }

    private void ॱ(int i) {
        this.ˎ.ˏ(i);
        this.ॱ.ˏ(this.ˎ.ˏ);
    }

    private static long ʼ(ane o_ane) {
        return (long) o_ane.ॱ((o_ane.ॱ(2) + 1) * 8);
    }
}
